home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / AOCE Sample Code / PowerTalk Access Modules / Sample SMSAM / SampleSMSAM Source / BuildingBlocks / OCEObjectsTests.cp < prev    next >
Encoding:
Text File  |  1995-07-28  |  21.8 KB  |  788 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        OCEObjectsTests.cp
  3.  
  4.     Copyright:    © 1991-1994 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Part of the AOCE Sample SMSAM Package.  Consult the license
  8.     which came with this software for your specific legal rights.
  9.  
  10. */
  11.  
  12.  
  13.  
  14. #if    debug
  15.  
  16. #ifndef    __OCEOBJECTSTESTS__
  17. #include "OCEObjectsTests.h"
  18. #endif
  19.  
  20. #ifndef    __OCEOBJECTS__
  21. #include "OCEObjects.h"
  22. #endif
  23.  
  24. #ifndef    __STRING__
  25. #include "String.h"
  26. #endif
  27.  
  28. #ifndef __RAMFILE__
  29. #include "RAMFile.h"
  30. #endif
  31.  
  32. #ifndef    __HANDLEOBJECTOWNER__
  33. #include "HandleObjectOwner.h"
  34. #endif
  35.  
  36. #pragma segment OCEObjectsTests
  37.  
  38. #ifndef THINK_CPLUS
  39.  
  40. /***********************************|****************************************/
  41.  
  42. Boolean EqualTest ( const TRString& r, const char* c )
  43. {
  44.     ASSERT_RETURN_ZERO ( r == c );
  45.     ASSERT_RETURN_ZERO ( !(r != c) );
  46.     ASSERT_RETURN_ZERO ( !(r > c) );
  47.     ASSERT_RETURN_ZERO ( !(r < c) );
  48.     const unsigned long rLength = r.GetLength ();
  49.     ASSERT_RETURN_ZERO ( rLength == ::strlen ( c ) );
  50.     ASSERT_RETURN_ZERO ( ::strcmp ( r, c ) == 0 );
  51.     for ( unsigned short index = 0; index < rLength; index++ )
  52.         ASSERT_RETURN_ZERO ( r [ index ] == c [ index ] );
  53.     return true;
  54. }
  55.  
  56. /***********************************|****************************************/
  57.  
  58. Boolean EqualTest ( const TRString& r, const StringPtr p )
  59. {
  60.     ASSERT_RETURN_ZERO ( r == p );
  61.     ASSERT_RETURN_ZERO ( !(r != p) );
  62.     ASSERT_RETURN_ZERO ( !(r > p) );
  63.     ASSERT_RETURN_ZERO ( !(r < p) );
  64.     const unsigned long rLength = r.GetLength ();
  65.     ASSERT_RETURN_ZERO ( rLength == Length ( p ) );
  66.     ASSERT_RETURN_ZERO ( ::EqualString ( r, p, true, true ) );
  67.     for ( unsigned short index = 0; index < rLength; index++ )
  68.         ASSERT_RETURN_ZERO ( r [ index ] == p [ index + 1 ] );
  69.     return true;
  70. }
  71.  
  72. /***********************************|****************************************/
  73.  
  74. Boolean ConstructTest ( const TRString& r1 )
  75. {
  76.     TRString r2 ( r1 );
  77.     ASSERT_RETURN_ZERO ( r1 == r2 );
  78.     TRString r3 ( (const RString*) r1 );
  79.     ASSERT_RETURN_ZERO ( r1 == r3 );
  80.     TRString r4 ( (const RString&) r1 );
  81.     ASSERT_RETURN_ZERO ( r1 == r4 );
  82.     TRString r5 ( (const char*) r1 );
  83.     ASSERT_RETURN_ZERO ( r1 == r5 );
  84.     TRString r6 ( (const StringPtr) r1 );
  85.     ASSERT_RETURN_ZERO ( r1 == r6 );
  86.     return true;
  87. }
  88.  
  89. /***********************************|****************************************/
  90.  
  91. Boolean AssignTest ( const TRString& r1 )
  92. {
  93.     TRString r2 = r1;
  94.     ASSERT_RETURN_ZERO ( r1 == r2 );
  95.     TRString r3 = (const RString*) r1;
  96.     ASSERT_RETURN_ZERO ( r1 == r3 );
  97.     TRString r4 = (const RString&) r1;
  98.     ASSERT_RETURN_ZERO ( r1 == r4 );
  99.     TRString r5 = (const char*) r1;
  100.     ASSERT_RETURN_ZERO ( r1 == r5 );
  101.     TRString r6 = (const StringPtr) r1;
  102.     ASSERT_RETURN_ZERO ( r1 == r6 );
  103.     return true;
  104. }
  105.  
  106. /***********************************|****************************************/
  107.  
  108. Boolean HalfEqualTest ( const TRString& r1, const TRString& r2 )
  109. {
  110.     ASSERT_RETURN_ZERO ( r1.IsValid () );
  111.     unsigned long r1Length = r1.GetLength ();
  112.     ASSERT_RETURN_ZERO ( r1Length == r2.GetLength () );
  113.     ASSERT_RETURN_ZERO ( r1.GetKind () == r2.GetKind () );
  114.     ASSERT_RETURN_ZERO ( r1.GetScript () == r2.GetScript () );
  115.     for ( unsigned short index = 0; index < r1Length; index++ )
  116.         ASSERT_RETURN_ZERO ( r1 [ index ] == r2 [ index ] );
  117.     ASSERT_RETURN_ZERO ( r1 == r2 );
  118.     ASSERT_RETURN_ZERO ( !(r1 != r2) );
  119.     ASSERT_RETURN_ZERO ( !(r1 > r2) );
  120.     ASSERT_RETURN_ZERO ( !(r1 < r2) );
  121.     ASSERT_RETURN_ZERO ( ::ConstructTest ( r1 ) );
  122.     ASSERT_RETURN_ZERO ( ::AssignTest ( r1 ) );
  123.     return true;
  124. }
  125.  
  126. /***********************************|****************************************/
  127.  
  128. Boolean EqualTest ( const TRString& r1, const TRString& r2 )
  129. {
  130.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r1, r2 ) );
  131.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r2, r1 ) );
  132.     return true;
  133. }
  134.  
  135. /***********************************|****************************************/
  136.  
  137. Boolean EqualTest ( const TRString& r1, const RString& r2 )
  138. {
  139.     ASSERT_RETURN_ZERO ( ::EqualTest ( r1, TRString ( r2 ) ) );
  140.     return true;
  141. }
  142.  
  143. /***********************************|****************************************/
  144.  
  145. extern Boolean StreamTest ( const TRString& r );
  146.  
  147. Boolean ValidityTest ( const TRString& r )
  148. {
  149.     ASSERT_RETURN_ZERO ( ::EqualTest ( r, (const char*) r ) );
  150.     ASSERT_RETURN_ZERO ( ::EqualTest ( r, (const StringPtr) r ) );
  151.  
  152.     TRString r1 ( (const RString*) r );
  153.     ASSERT_RETURN_ZERO ( ::EqualTest ( r1, r ) );
  154.  
  155.     TRString r5 = (const RString*) r;
  156.     ASSERT_RETURN_ZERO ( ::EqualTest ( r5, r ) );
  157.  
  158.     RString* rs = r.GetNewRString ();
  159.     ASSERT_RETURN_ZERO ( rs != nil );
  160.     TRString r2 ( rs );
  161.     ASSERT_RETURN_ZERO ( ::EqualTest ( r, r2 ) );
  162.     r1 = *rs;
  163.     ASSERT_RETURN_ZERO ( ::EqualTest ( r1, r2 ) );
  164.     ::DeallocatePtr( (Ptr) rs );
  165.  
  166.     StringPtr ps = r.GetNewStringPtr ();
  167.     TRString r3 ( ps );
  168.     ASSERT_RETURN_ZERO ( ::EqualTest ( r3, ps ) );
  169.     ::DeallocatePtr( (Ptr) ps );
  170.  
  171.     char* cs = r.GetNewString ();
  172.     TRString r4 ( cs );
  173.     ASSERT_RETURN_ZERO ( ::EqualTest ( r4, cs ) );
  174.     ::DeallocatePtr( (Ptr) cs );
  175.  
  176.     ASSERT_RETURN_ZERO ( ::StreamTest ( r1 ) );
  177.  
  178.     return true;
  179. }
  180.  
  181. /***********************************|****************************************/
  182.  
  183. Boolean StreamTest ( const TRString& r )
  184. {
  185.     TAbstractFile* file = new TRamFile;
  186.     THandleObjectOwner owner ( file );
  187.     
  188. // write the object and and rewind
  189.     ASSERT_RETURN_ZERO ( r.Write ( *file ) );
  190.     ASSERT_RETURN_ZERO ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  191.  
  192. // read a new object
  193.     TRString r2;
  194.     ASSERT_RETURN_ZERO ( r2.Read ( *file ) );
  195.  
  196. // make sure they are equal
  197.     ASSERT_RETURN_ZERO ( ::EqualTest ( r, r2 ) );
  198.  
  199.     return true;
  200. }
  201.  
  202. /***********************************|****************************************/
  203.  
  204. void TRStringTests ()
  205. {
  206. // test data
  207.     const char* c1 = "Sample String 1";
  208.     const StringPtr p1 = "\pSample String 1";
  209.     const char* c2 = "This is the third sample string!";
  210.     const StringPtr p2 = "\pThis is another sample string?!?!";
  211.  
  212. // constructors
  213.     TRString rc1 ( c1 );
  214.     ASSERT_RETURN ( ::ValidityTest ( rc1 ) );
  215.  
  216.     TRString rp1 ( p1 );
  217.     ASSERT_RETURN ( ::ValidityTest ( rp1 ) );
  218.     ASSERT_RETURN ( ::EqualTest ( rp1, rc1 ) );
  219.  
  220.     TRString rr1 ( rc1 );
  221.     ASSERT_RETURN ( ::ValidityTest ( rp1 ) );
  222.     ASSERT_RETURN ( ::EqualTest ( rr1, rc1 ) );
  223.     ASSERT_RETURN ( ::EqualTest ( rr1, rp1 ) );
  224.  
  225. // case setting
  226.     rc1.MakeLowercase ();
  227.     ASSERT_RETURN ( ::EqualTest ( rc1, "sample string 1" ) );
  228.     rc1.MakeUppercase ();
  229.     ASSERT_RETURN ( ::EqualTest ( rc1, "SAMPLE STRING 1" ) );
  230.  
  231. // character setting
  232.     chris << "The following ASSERT FAILED “IsValidIndex ( index )” is supposed to happen!\n";
  233.     rc1 [ 15 ] = 'X';    // this should fail!
  234.     ASSERT_RETURN ( ::EqualTest ( rc1, "SAMPLE STRING 1" ) );
  235.     rc1 [ 14 ] = 'X';    // this should work!
  236.     ASSERT_RETURN ( ::EqualTest ( rc1, "SAMPLE STRING X" ) );
  237.     ASSERT_RETURN ( rc1 [ 14 ] == 'X' );
  238.     rc1 [ 0 ] = 'Z';    // this should work!
  239.     ASSERT_RETURN ( ::EqualTest ( rc1, "ZAMPLE STRING X" ) );
  240.     ASSERT_RETURN ( rc1 [ 0 ] == 'Z' );
  241.  
  242. // assignment
  243.     rc1 = p2;
  244.     ASSERT_RETURN ( ::EqualTest ( rc1, p2 ) );
  245.  
  246.     rc1 = c2;
  247.     ASSERT_RETURN ( ::EqualTest ( rc1, c2 ) );
  248.  
  249.     rp1 = rc1;
  250.     ASSERT_RETURN ( ::EqualTest ( rp1, rc1 ) );
  251.  
  252.     chris << "RString: " << rc1 << '\n';
  253. }
  254.  
  255. /***********************************|****************************************/
  256.  
  257. Boolean EqualTest ( const TCreationID& o, const CreationID& c )
  258. {
  259.     ASSERT_RETURN_ZERO ( o == c );
  260.     ASSERT_RETURN_ZERO ( !(o != c) );
  261.     CreationID c2;
  262.     o.GetID ( c2 );
  263.     ASSERT_RETURN_ZERO ( c2.source == c.source );
  264.     ASSERT_RETURN_ZERO ( c2.seq == c.seq );
  265.     unsigned long source, seq;
  266.     o.GetID ( source, seq );
  267.     ASSERT_RETURN_ZERO ( source == c.source );
  268.     ASSERT_RETURN_ZERO ( seq == c.seq );
  269.     return true;
  270. }
  271.  
  272. /***********************************|****************************************/
  273.  
  274. void CreationIDTests ()
  275. {
  276.     CreationID c;
  277.     c.source = 1234;
  278.     c.seq = 5678;
  279.  
  280. // construction
  281.     TCreationID o1 ( 1234, 5678 );
  282.     ASSERT_RETURN ( ::EqualTest ( o1, c ) );
  283.     ASSERT_RETURN ( !o1.IsNull () );
  284.  
  285.     TCreationID o2 ( c );
  286.     ASSERT_RETURN ( ::EqualTest ( o2, c ) );
  287.     ASSERT_RETURN ( o1 == o2 );
  288.  
  289.     TCreationID o3 = c;
  290.     ASSERT_RETURN ( ::EqualTest ( o3, c ) );
  291.     ASSERT_RETURN ( o3 == o2 );
  292.  
  293.     TCreationID o5 ( o1 );
  294.     ASSERT_RETURN ( o5 == o1 );
  295.  
  296.     TCreationID o6 = o1;
  297.     ASSERT_RETURN ( o6 == o1 );
  298.  
  299. // streaming
  300.     TAbstractFile* file = new TRamFile;
  301.     THandleObjectOwner owner ( file );
  302.     ASSERT_RETURN ( o1.Write ( *file ) );
  303.     ASSERT_RETURN ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  304.     TCreationID o4;
  305.     ASSERT_RETURN ( o4.IsNull () );
  306.     ASSERT_RETURN ( o4.Read ( *file ) );
  307.     ASSERT_RETURN ( ::EqualTest ( o4, c ) );
  308.     ASSERT_RETURN ( o4 == o1 );
  309.  
  310.     chris << "CreationID: " << o1 << '\n';
  311. }
  312.  
  313. /***********************************|****************************************/
  314.  
  315. Boolean EqualTest ( const TDirDiscriminator& o, const DirDiscriminator& c )
  316. {
  317.     ASSERT_RETURN_ZERO ( o == c );
  318.     ASSERT_RETURN_ZERO ( !(o != c) );
  319.     DirDiscriminator c2;
  320.     o.GetDiscriminator ( c2 );
  321.     ASSERT_RETURN_ZERO ( c2.signature == c.signature );
  322.     ASSERT_RETURN_ZERO ( c2.misc == c.misc );
  323.     OCEDirectoryKind signature;
  324.     unsigned long misc;
  325.     o.GetDiscriminator ( signature, misc );
  326.     ASSERT_RETURN_ZERO ( signature == c.signature );
  327.     ASSERT_RETURN_ZERO ( misc == c.misc );
  328.     return true;
  329. }
  330.  
  331. /***********************************|****************************************/
  332.  
  333. void DirDiscriminatorTests ()
  334. {
  335.     DirDiscriminator c;
  336.     c.signature = 1234;
  337.     c.misc = 5678;
  338.  
  339. // construction
  340.     TDirDiscriminator o1 ( 1234, 5678 );
  341.     ASSERT_RETURN ( ::EqualTest ( o1, c ) );
  342.  
  343.     TDirDiscriminator o2 ( c );
  344.     ASSERT_RETURN ( ::EqualTest ( o2, c ) );
  345.     ASSERT_RETURN ( o1 == o2 );
  346.  
  347.     TDirDiscriminator o3 = c;
  348.     ASSERT_RETURN ( ::EqualTest ( o3, c ) );
  349.     ASSERT_RETURN ( o3 == o2 );
  350.  
  351.     TDirDiscriminator o5 ( o1 );
  352.     ASSERT_RETURN ( o5 == o1 );
  353.  
  354.     TDirDiscriminator o6 = o1;
  355.     ASSERT_RETURN ( o6 == o1 );
  356.  
  357. // streaming
  358.     TAbstractFile* file = new TRamFile;
  359.     THandleObjectOwner owner ( file );
  360.     ASSERT_RETURN ( o1.Write ( *file ) );
  361.     ASSERT_RETURN ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  362.     TDirDiscriminator o4;
  363.     ASSERT_RETURN ( o4.Read ( *file ) );
  364.     ASSERT_RETURN ( ::EqualTest ( o4, c ) );
  365.     ASSERT_RETURN ( o4 == o1 );
  366.  
  367.     chris << "DirDiscriminator: " << o1 << '\n';
  368. }
  369.  
  370. /***********************************|****************************************/
  371.  
  372. Boolean StreamTest ( const TPathName& p )
  373. {
  374.     TAbstractFile* file = new TRamFile;
  375.     THandleObjectOwner owner ( file );
  376.     ASSERT_RETURN_ZERO ( p.Write ( *file ) );
  377.     ASSERT_RETURN_ZERO ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  378.     TPathName p2;
  379.     ASSERT_RETURN_ZERO ( p2.Read ( *file ) );
  380.     ASSERT_RETURN_ZERO ( p == p2 );
  381.     return true;
  382. }
  383.  
  384. /***********************************|****************************************/
  385.  
  386. Boolean ValidityTest ( const TPathName& p )
  387. {
  388.     ASSERT_RETURN_ZERO ( p.IsValid () );
  389.     ASSERT_RETURN_ZERO ( TPathName::IsValid ( (const PackedPathName*) p ) );
  390.  
  391.     const unsigned short count = p.GetNodeCount ();
  392.     ASSERT_RETURN_ZERO ( count > 0 || p.IsNull () );
  393.     ASSERT_RETURN_ZERO ( count > 0 && !p.IsNull () );
  394.  
  395.     for ( unsigned short index = 0; index < count; index++ )
  396.     {
  397.         ASSERT_RETURN_ZERO ( p.IsValidIndex ( index ) );
  398.         ASSERT_RETURN_ZERO ( TRString ( p [ index ] ).IsValid () );
  399.     }
  400.  
  401.     ASSERT_RETURN_ZERO ( !p.IsValidIndex ( count ) );
  402.     ASSERT_RETURN_ZERO ( ::StreamTest ( p ) );
  403.     return true;
  404. }
  405.  
  406. /***********************************|****************************************/
  407.  
  408. Boolean ConstructTest ( const TPathName& r1 )
  409. {
  410.     TPathName r2 ( r1 );
  411.     ASSERT_RETURN_ZERO ( r1 == r2 );
  412.     TPathName r3 ( (const PackedPathName*) r1 );
  413.     ASSERT_RETURN_ZERO ( r1 == r3 );
  414.     TPathName r4 ( (const PackedPathName&) r1 );
  415.     ASSERT_RETURN_ZERO ( r1 == r4 );
  416.     return true;
  417. }
  418.  
  419. /***********************************|****************************************/
  420.  
  421. Boolean AssignTest ( const TPathName& r1 )
  422. {
  423.     TPathName r2 = r1;
  424.     ASSERT_RETURN_ZERO ( r1 == r2 );
  425.     TPathName r3 = (const PackedPathName*) r1;
  426.     ASSERT_RETURN_ZERO ( r1 == r3 );
  427.     TPathName r4 = (const PackedPathName&) r1;
  428.     ASSERT_RETURN_ZERO ( r1 == r4 );
  429.     return true;
  430. }
  431.  
  432. /***********************************|****************************************/
  433.  
  434. Boolean HalfEqualTest ( const TPathName& p1, const TPathName& p2 )
  435. {
  436.     ASSERT_RETURN_ZERO ( ::ValidityTest ( p1 ) );
  437.     const unsigned short count = p1.GetNodeCount ();
  438.     ASSERT_RETURN_ZERO ( count == p2.GetNodeCount () );
  439.     ASSERT_RETURN_ZERO ( p1 == p2 );
  440.     ASSERT_RETURN_ZERO ( !(p1 != p2) );
  441.  
  442.     for ( unsigned short index = 0; index < count; index++ )
  443.         ASSERT_RETURN_ZERO ( ::EqualTest ( TRString ( p1 [ index ] ), TRString ( p2 [ index ] ) ) );
  444.  
  445.     ASSERT_RETURN_ZERO ( ::ConstructTest ( p1 ) );
  446.     ASSERT_RETURN_ZERO ( ::AssignTest ( p1 ) );
  447.  
  448.     return true;
  449. }
  450.  
  451. /***********************************|****************************************/
  452.  
  453. Boolean EqualTest ( const TPathName& p1, const TPathName& p2 )
  454. {
  455.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( p1, p2 ) );
  456.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( p2, p1 ) );
  457.     return true;
  458. }
  459.  
  460. /***********************************|****************************************/
  461.  
  462. void TPathnameTests ()
  463. {
  464.     TRString r1 ( "ROOT" );
  465.     TRString r2 ( "TRUNK" );
  466.     TRString r3 ( "LEAF" );
  467.  
  468.     TPathName p0;
  469.     ASSERT_RETURN ( p0.IsNull () );
  470.  
  471.     TPathName p1 ( r1 );
  472.     chris << "PathName: " << p1 << '\n';
  473.     ASSERT_RETURN ( p1.GetNodeCount () == 1 );
  474.     p0 = p1;
  475.     ASSERT_RETURN ( ::EqualTest ( p0, p1 ) );
  476.     ASSERT_RETURN ( ::EqualTest ( r1, p1 [ 0 ] ) );
  477.  
  478.     TPathName p2 ( r1, r2 );
  479.     chris << "PathName: " << p2 << '\n';
  480.     ASSERT_RETURN ( p2.GetNodeCount () == 2 );
  481.     p0 = p2;
  482.     ASSERT_RETURN ( ::EqualTest ( p0, p2 ) );
  483.     ASSERT_RETURN ( ::EqualTest ( r1, p2 [ 0 ] ) );
  484.     ASSERT_RETURN ( ::EqualTest ( r2, p2 [ 1 ] ) );
  485.  
  486.     TPathName p3 ( r1, r2, r3 );
  487.     chris << "PathName: " << p3 << '\n';
  488.     ASSERT_RETURN ( p3.GetNodeCount () == 3 );
  489.     p0 = p3;
  490.     ASSERT_RETURN ( ::EqualTest ( p0, p3 ) );
  491.     ASSERT_RETURN ( ::EqualTest ( r1, p3 [ 0 ] ) );
  492.     ASSERT_RETURN ( ::EqualTest ( r2, p3 [ 1 ] ) );
  493.     ASSERT_RETURN ( ::EqualTest ( r3, p3 [ 2 ] ) );
  494.     ASSERT_RETURN ( ::EqualTest ( r1, p0 [ 0 ] ) );
  495.     ASSERT_RETURN ( ::EqualTest ( r2, p0 [ 1 ] ) );
  496.     ASSERT_RETURN ( ::EqualTest ( r3, p0 [ 2 ] ) );
  497.  
  498.     TPathName p4 ( p3 );
  499.     chris << "PathName: " << p4 << '\n';
  500.     ASSERT_RETURN ( ::EqualTest ( p4, p3 ) );
  501.     ASSERT_RETURN ( ::EqualTest ( r1, p4 [ 0 ] ) );
  502.     ASSERT_RETURN ( ::EqualTest ( r2, p4 [ 1 ] ) );
  503.     ASSERT_RETURN ( ::EqualTest ( r3, p4 [ 2 ] ) );
  504.  
  505.     ASSERT_RETURN ( ::EqualTest ( TRString ( "ROOT" ), p4 [ 0 ] ) );
  506.     ASSERT_RETURN ( ::EqualTest ( TRString ( "TRUNK" ), p4 [ 1 ] ) );
  507.     ASSERT_RETURN ( ::EqualTest ( TRString ( "LEAF" ), p4 [ 2 ] ) );
  508. }
  509.  
  510. /***********************************|****************************************/
  511.  
  512. Boolean ConstructTest ( const TRLI& r1 )
  513. {
  514.     TRLI r2 ( r1 );
  515.     ASSERT_RETURN_ZERO ( r1 == r2 );
  516.     TRLI r3 ( (const PackedRLI*) r1 );
  517.     ASSERT_RETURN_ZERO ( r1 == r3 );
  518.     TRLI r4 ( (const PackedRLI&) r1 );
  519.     ASSERT_RETURN_ZERO ( r1 == r4 );
  520.     TRLI r5 ( (const RLI*) r1 );
  521.     ASSERT_RETURN_ZERO ( r1 == r5 );
  522.     TRLI r6 ( (const RLI&) r1 );
  523.     ASSERT_RETURN_ZERO ( r1 == r6 );
  524.     return true;
  525. }
  526.  
  527. /***********************************|****************************************/
  528.  
  529. Boolean AssignTest ( const TRLI& r1 )
  530. {
  531.     TRLI r2 = r1;
  532.     ASSERT_RETURN_ZERO ( r1 == r2 );
  533.     TRLI r3 = (const PackedRLI*) r1;
  534.     ASSERT_RETURN_ZERO ( r1 == r3 );
  535.     TRLI r4 = (const PackedRLI&) r1;
  536.     ASSERT_RETURN_ZERO ( r1 == r4 );
  537.     TRLI r5 = (const RLI*) r1;
  538.     ASSERT_RETURN_ZERO ( r1 == r5 );
  539.     TRLI r6 = (const RLI&) r1;
  540.     ASSERT_RETURN_ZERO ( r1 == r6 );
  541.     return true;
  542. }
  543.  
  544. /***********************************|****************************************/
  545.  
  546. Boolean HalfEqualTest ( const TRLI& r1, const TRLI& r2 )
  547. {
  548.     ASSERT_RETURN_ZERO ( r1.IsValid () );
  549.     ASSERT_RETURN_ZERO ( TRLI::IsValid ( (const RLI*) r1 ) );
  550.     ASSERT_RETURN_ZERO ( TRLI::IsValid ( (const PackedRLI*) r1 ) );
  551.  
  552.     ASSERT_RETURN_ZERO ( r1 == r2 );
  553.     ASSERT_RETURN_ZERO ( !(r1 != r2) );
  554.  
  555.     TDirectory d1, d2;
  556.     ASSERT_RETURN_ZERO ( r1.GetDirectory ( d1 ) );
  557.     ASSERT_RETURN_ZERO ( r2.GetDirectory ( d2 ) );
  558.     ASSERT_RETURN_ZERO ( d1 == d2 );
  559.  
  560.     TPathName p1, p2;
  561.     ASSERT_RETURN_ZERO ( r1.GetPathName ( p1 ) );
  562.     ASSERT_RETURN_ZERO ( r2.GetPathName ( p2 ) );
  563.     ASSERT_RETURN_ZERO ( p1 == p2 );
  564.  
  565.     ASSERT_RETURN_ZERO ( r1.GetNode () == r2.GetNode () );
  566.  
  567.     ASSERT_RETURN_ZERO ( ::ConstructTest ( r1 ) );
  568.     ASSERT_RETURN_ZERO ( ::AssignTest ( r1 ) );
  569.  
  570.     return true;
  571. }
  572.  
  573. /***********************************|****************************************/
  574.  
  575. Boolean EqualTest ( const TRLI& r1, const TRLI& r2 )
  576. {
  577.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r1, r2 ) );
  578.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r2, r1 ) );
  579.     return true;
  580. }
  581.  
  582. /***********************************|****************************************/
  583.  
  584. void TRLITests ()
  585. {
  586.     TDirectory directory ( "directory", 'DISC' );
  587.     TPathName path ( "root", "trunk", "leaf" );
  588.     TRLI r1 ( directory, path, 1234 );
  589.     TRLI r2 = r1;
  590.     ASSERT_RETURN ( ::EqualTest ( r1, r2 ) );
  591.  
  592.     TDirectory dir2 ( "folder" ), dir3;
  593.     r1.SetDirectory ( dir2 );
  594.     ASSERT_RETURN ( r1.GetDirectory ( dir3 ) );
  595.     ASSERT_RETURN ( dir2 == dir3 );
  596.  
  597.     TPathName path2 ( "pathname" ), path3;
  598.     r1.SetPathName ( path2 );
  599.     ASSERT_RETURN ( r1.GetPathName ( path3 ) );
  600.     ASSERT_RETURN ( ::EqualTest ( path2, path3 ) );
  601.  
  602. // streaming
  603.     TAbstractFile* file = new TRamFile;
  604.     THandleObjectOwner owner ( file );
  605.     ASSERT_RETURN ( r1.Write ( *file ) );
  606.     ASSERT_RETURN ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  607.     TRLI r3;
  608.     ASSERT_RETURN ( r3.Read ( *file ) );
  609.     ASSERT_RETURN ( ::HalfEqualTest ( r3, r1 ) );
  610.  
  611.     chris << "RLI: " << r1 << '\n';
  612. }
  613.  
  614. /***********************************|****************************************/
  615.  
  616. Boolean ConstructTest ( const TRecordID& r1 )
  617. {
  618.     TRecordID r2 ( r1 );
  619.     ASSERT_RETURN_ZERO ( r1 == r2 );
  620.     TRecordID r3 ( (const PackedRecordID*) r1 );
  621.     ASSERT_RETURN_ZERO ( r1 == r3 );
  622.     TRecordID r4 ( (const PackedRecordID&) r1 );
  623.     ASSERT_RETURN_ZERO ( r1 == r4 );
  624.     TRecordID r5 ( (const RecordID*) r1 );
  625.     ASSERT_RETURN_ZERO ( r1 == r5 );
  626.     TRecordID r6 ( (const RecordID&) r1 );
  627.     ASSERT_RETURN_ZERO ( r1 == r6 );
  628.     return true;
  629. }
  630.  
  631. /***********************************|****************************************/
  632.  
  633. Boolean AssignTest ( const TRecordID& r1 )
  634. {
  635.     TRecordID r2 = r1;
  636.     ASSERT_RETURN_ZERO ( r1 == r2 );
  637.     TRecordID r3 = (const PackedRecordID*) r1;
  638.     ASSERT_RETURN_ZERO ( r1 == r3 );
  639.     TRecordID r4 = (const PackedRecordID&) r1;
  640.     ASSERT_RETURN_ZERO ( r1 == r4 );
  641.     TRecordID r5 = (const RecordID*) r1;
  642.     ASSERT_RETURN_ZERO ( r1 == r5 );
  643.     TRecordID r6 = (const RecordID&) r1;
  644.     ASSERT_RETURN_ZERO ( r1 == r6 );
  645.     return true;
  646. }
  647.  
  648. /***********************************|****************************************/
  649.  
  650. Boolean HalfEqualTest ( const TRecordID& r1, const TRecordID& r2 )
  651. {
  652.     ASSERT_RETURN_ZERO ( r1.IsValid () );
  653.     ASSERT_RETURN_ZERO ( TRecordID::IsValid ( (const PackedRecordID*) r1 ) );
  654.     ASSERT_RETURN_ZERO ( TRecordID::IsValid ( (const RecordID*) r1 ) );
  655.  
  656.     ASSERT_RETURN_ZERO ( r1 == r2 );
  657.     ASSERT_RETURN_ZERO ( !(r1 != r2) );
  658.  
  659.     TRString rs1, rs2;
  660.     ASSERT_RETURN_ZERO ( r1.GetRecordName ( rs1 ) );
  661.     ASSERT_RETURN_ZERO ( r2.GetRecordName ( rs2 ) );
  662.     ASSERT_RETURN_ZERO ( rs1 == rs2 );
  663.     ASSERT_RETURN_ZERO ( r1.GetRecordType ( rs1 ) );
  664.     ASSERT_RETURN_ZERO ( r2.GetRecordType ( rs2 ) );
  665.     ASSERT_RETURN_ZERO ( rs1 == rs2 );
  666.  
  667.     TCreationID c1, c2;
  668.     ASSERT_RETURN_ZERO ( r1.GetCreationID ( c1 ) );
  669.     ASSERT_RETURN_ZERO ( r2.GetCreationID ( c2 ) );
  670.     ASSERT_RETURN_ZERO ( c1 == c2 );
  671.  
  672.     TPathName p1, p2;
  673.     ASSERT_RETURN_ZERO ( r1.GetPathName ( p1 ) );
  674.     ASSERT_RETURN_ZERO ( r2.GetPathName ( p2 ) );
  675.     ASSERT_RETURN_ZERO ( p1 == p2 );
  676.  
  677.     TDirectory d1, d2;
  678.     ASSERT_RETURN_ZERO ( r1.GetDirectory ( d1 ) );
  679.     ASSERT_RETURN_ZERO ( r2.GetDirectory ( d2 ) );
  680.     ASSERT_RETURN_ZERO ( d1 == d2 );
  681.  
  682.     TRLI rl1, rl2;
  683.     ASSERT_RETURN_ZERO ( r1.GetRLI ( rl1 ) );
  684.     ASSERT_RETURN_ZERO ( r2.GetRLI ( rl2 ) );
  685.     ASSERT_RETURN_ZERO ( rl1 == rl2 );
  686.  
  687.     ASSERT_RETURN_ZERO ( r1.GetNode () == r2.GetNode () );
  688.  
  689.     ASSERT_RETURN_ZERO ( ::ConstructTest ( r1 ) );
  690.     ASSERT_RETURN_ZERO ( ::AssignTest ( r1 ) );
  691.  
  692.     return true;
  693. }
  694.  
  695. /***********************************|****************************************/
  696.  
  697. Boolean EqualTest ( const TRecordID& r1, const TRecordID& r2 )
  698. {
  699.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r1, r2 ) );
  700.     ASSERT_RETURN_ZERO ( ::HalfEqualTest ( r2, r1 ) );
  701.     return true;
  702. }
  703.  
  704. /***********************************|****************************************/
  705.  
  706. #define    PRINT_SIZE(C) chris << "sizeof ( " << #C << ") = " << sizeof ( C ) << '\n'
  707.  
  708. static void ReportSizes ()
  709. {
  710.     PRINT_SIZE ( TRString );
  711.     PRINT_SIZE ( TDirectoryName );
  712.     PRINT_SIZE ( TCreationID );
  713.     PRINT_SIZE ( TDirDiscriminator );
  714.     PRINT_SIZE ( TPathName );
  715.     PRINT_SIZE ( TRLI );
  716.     PRINT_SIZE ( TRecordID );
  717. }
  718.  
  719. /***********************************|****************************************/
  720.  
  721. void RunAllOCEOjectsTests ()
  722. {
  723.     Boolean prev = ::GetOCEObjectsInternalValidityChecking ();
  724.     ::SetOCEObjectsInternalValidityChecking ( true );
  725.  
  726.     ReportSizes ();
  727.     TRStringTests ();
  728.     CreationIDTests ();
  729.     DirDiscriminatorTests ();
  730.     TPathnameTests ();
  731.     TRLITests ();
  732.     TRecordIDTests ();
  733.  
  734.     ::SetOCEObjectsInternalValidityChecking ( prev );
  735. }
  736.  
  737. /***********************************|****************************************/
  738.  
  739. void TRecordIDTests ()
  740. {
  741.     TRecordID r1 ( "name", "type", TPathName ( "a", "b" ), TDirectory ( "directory" ) );
  742.     TRecordID r2 = r1;
  743.  
  744.     ASSERT_RETURN ( ::EqualTest ( r1, r2 ) );
  745.  
  746.     TRString s2 ( "new record name" ), s3;
  747.     ASSERT_RETURN ( r1.SetRecordName ( s2 ) );
  748.     ASSERT_RETURN ( r1.GetRecordName ( s3 ) );
  749.     ASSERT_RETURN ( ::EqualTest ( s2, s3 ) );
  750.  
  751.     TRString s4 ( "new record type" ), s5;
  752.     ASSERT_RETURN ( r2.SetRecordType ( s4 ) );
  753.     ASSERT_RETURN ( r2.GetRecordType ( s5 ) );
  754.     ASSERT_RETURN ( ::EqualTest ( s4, s5 ) );
  755.  
  756.     TCreationID id1 ( 1, 2 ), id2;
  757.     ASSERT_RETURN ( r2.SetCreationID ( id1 ) );
  758.     ASSERT_RETURN ( r2.GetCreationID ( id2 ) );
  759.     ASSERT_RETURN ( ::EqualTest ( id1, id2 ) );
  760.  
  761.     TDirectory dir2 ( "new directory" ), dir3;
  762.     ASSERT_RETURN ( r2.SetDirectory ( dir2 ) );
  763.     ASSERT_RETURN ( r2.GetDirectory ( dir3 ) );
  764.     ASSERT_RETURN ( dir2 == dir3 );
  765.  
  766.     TPathName path2 ( "new path" ), path3;
  767.     ASSERT_RETURN ( r2.SetPathName ( path2 ) );
  768.     ASSERT_RETURN ( r2.GetPathName ( path3 ) );
  769.     ASSERT_RETURN ( ::EqualTest ( path2, path3 ) );
  770.  
  771. // streaming
  772.     TAbstractFile* file = new TRamFile;
  773.     THandleObjectOwner owner ( file );
  774.     ASSERT_RETURN ( r1.Write ( *file ) );
  775.     ASSERT_RETURN ( file->SetPosition ( fsFromMark, 0 ) == noErr );
  776.     TRecordID r3;
  777.     ASSERT_RETURN ( r3.Read ( *file ) );
  778.     ASSERT_RETURN ( ::EqualTest ( r3, r1 ) );
  779.  
  780.     chris << "RecordID #1: " << r1 << '\n';
  781.     chris << "RecordID #2: " << r2 << '\n';
  782. }
  783.  
  784. /***********************************|****************************************/
  785.  
  786. #endif
  787.  
  788. #endif    // debug